package org.hbhk.hxl.gateway.exception;

import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.hbhk.hxl.gateway.filter.breaker.BreakerManager;
import org.hbhk.hxl.gateway.model.Circuitbreaker;
import org.hbhk.hxl.gateway.model.ResultMsg;
import org.hbhk.hxl.gateway.services.ServiceUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.web.reactive.error.ErrorWebExceptionHandler;
import org.springframework.cloud.gateway.support.NotFoundException;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.codec.HttpMessageReader;
import org.springframework.http.codec.HttpMessageWriter;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.util.Assert;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.server.RequestPredicates;
import org.springframework.web.reactive.function.server.RouterFunctions;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.reactive.function.server.ServerResponse;
import org.springframework.web.reactive.result.view.ViewResolver;
import org.springframework.web.server.ResponseStatusException;
import org.springframework.web.server.ServerWebExchange;

import com.alibaba.fastjson.JSON;

import reactor.core.publisher.Mono;

/**
 * @classDesc: 统一异常处理,参考{@link org.springframework.web.server.AbstractErrorWebExceptionHandler}修改
 */
public class GlobalExceptionHandler implements ErrorWebExceptionHandler {

	private static final Logger log = LoggerFactory.getLogger(GlobalExceptionHandler.class);

	/**
	 * MessageReader
	 */
	private List<HttpMessageReader<?>> messageReaders = Collections.emptyList();

	/**
	 * MessageWriter
	 */
	private List<HttpMessageWriter<?>> messageWriters = Collections.emptyList();

	/**
	 * ViewResolvers
	 */
	private List<ViewResolver> viewResolvers = Collections.emptyList();

	/**
	 * 存储处理异常后的信息
	 */
	private ThreadLocal<Map<String, Object>> exceptionHandlerResult = new ThreadLocal<>();

	/**
	 * 参考AbstractErrorWebExceptionHandler
	 * 
	 * @param messageReaders
	 */
	public void setMessageReaders(List<HttpMessageReader<?>> messageReaders) {
		Assert.notNull(messageReaders, "'messageReaders' must not be null");
		this.messageReaders = messageReaders;
	}

	/**
	 * 参考AbstractErrorWebExceptionHandler
	 * 
	 * @param viewResolvers
	 */
	public void setViewResolvers(List<ViewResolver> viewResolvers) {
		this.viewResolvers = viewResolvers;
	}

	/**
	 * 参考AbstractErrorWebExceptionHandler
	 * 
	 * @param messageWriters
	 */
	public void setMessageWriters(List<HttpMessageWriter<?>> messageWriters) {
		Assert.notNull(messageWriters, "'messageWriters' must not be null");
		this.messageWriters = messageWriters;
	}

	@Override
	public Mono<Void> handle(ServerWebExchange exchange, Throwable ex) {

		ServerHttpRequest request = exchange.getRequest();
		/**
		 * 错误记录
		 */
		log.error("[全局异常处理]异常请求路径:{},记录异常信息:{}", request.getPath(), ex.getMessage());
		/**
		 * * 按照异常类型进行处理
		 */
		HttpStatus httpStatus;
		String body = ex.getMessage();
		if (ex instanceof NotFoundException) {
			httpStatus = HttpStatus.NOT_FOUND;
		} else if (ex instanceof ResponseStatusException) {
			ResponseStatusException responseStatusException = (ResponseStatusException) ex;
			httpStatus = responseStatusException.getStatus();
		} else {
			httpStatus = HttpStatus.INTERNAL_SERVER_ERROR;
		}
		if (!(ex instanceof RouteException)) {
			String url = request.getURI().getPath();
			Circuitbreaker breaker = ServiceUtil.getBreaker(url);
			if (breaker != null) {
				BreakerManager manager = BreakerManager.getBreakerManager(url);
				if (manager != null) {
					try {
						manager.actUponException();
						manager.protectedCodeHasBeenCalled();
					} catch (Exception e) {
						body = e.getMessage();
					}

				}
			}
		}

		ResultMsg data = new ResultMsg();
		data.setCode(String.valueOf(httpStatus.value()));
		data.setMessage(body);
		data.setSuccess(false);
		String resultStr = JSON.toJSONString(data);
		/**
		 * 封装响应体,此body可修改为自己的jsonBody
		 */
		Map<String, Object> result = new HashMap<>(2, 1);
		result.put("httpStatus", httpStatus);
		result.put("body", resultStr);

		/**
		 * 参考AbstractErrorWebExceptionHandler
		 */
		if (exchange.getResponse().isCommitted()) {
			return Mono.error(ex);
		}
		exceptionHandlerResult.set(result);
		ServerRequest newRequest = ServerRequest.create(exchange, this.messageReaders);
		return RouterFunctions.route(RequestPredicates.all(), this::renderErrorResponse).route(newRequest)
				.switchIfEmpty(Mono.error(ex)).flatMap((handler) -> handler.handle(newRequest))
				.flatMap((response) -> write(exchange, response));

	}

	/**
	 * 参考DefaultErrorWebExceptionHandler
	 * 
	 * @param request
	 * @return
	 */
	protected Mono<ServerResponse> renderErrorResponse(ServerRequest request) {
		Map<String, Object> result = exceptionHandlerResult.get();
		return ServerResponse.status((HttpStatus) result.get("httpStatus")).contentType(MediaType.APPLICATION_JSON_UTF8)
				.body(BodyInserters.fromObject(result.get("body")));
	}

	/**
	 * 参考AbstractErrorWebExceptionHandler
	 * 
	 * @param exchange
	 * @param response
	 * @return
	 */
	private Mono<? extends Void> write(ServerWebExchange exchange, ServerResponse response) {
		exchange.getResponse().getHeaders().setContentType(response.headers().getContentType());
		return response.writeTo(exchange, new ResponseContext());
	}

	/**
	 * 参考AbstractErrorWebExceptionHandler
	 */
	private class ResponseContext implements ServerResponse.Context {

		@Override
		public List<HttpMessageWriter<?>> messageWriters() {
			return GlobalExceptionHandler.this.messageWriters;
		}

		@Override
		public List<ViewResolver> viewResolvers() {
			return GlobalExceptionHandler.this.viewResolvers;
		}

	}
}